﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace LeetCode
{
    public class _66PlusOne : IRun
    {
        /*
         * 给定一个由整数组成的非空数组所表示的非负整数，在该数的基础上加一。
         * 最高位数字存放在数组的首位， 数组中每个元素只存储一个数字。
         * 你可以假设除了整数 0 之外，这个整数不会以零开头。
         * 
         * [1,2,2] => [1,2,3]
         */
        public void Run()
        {
            int[] _Reuslt = PlusOne1(new int[] { 8, 9, 9, 9 });
        }
        public static int[] PlusOne(int[] digits)
        {
            // 9999999999999999999z则无法计算；
            //未考虑数字过大问题
            long _Sum = 0;
            for (int i = 0; i < digits.Length; i++)
            {
                _Sum = _Sum * 10 + digits[i];
            }
            _Sum++;

            List<int> _List = new List<int>();
            while (_Sum > 0)
            {
                _List.Add((int)(_Sum % 10));
                _Sum = _Sum / 10;
            }

            _List.Reverse();
            return _List.ToArray(); 
        }

        public static int[] PlusOne1(int[] digits)
        {
            int _Sum = 0;
            int _Index = 1;
            for (int i = 0; i < digits.Length; i++)
            {
                if (digits[i] != 9)
                {
                    break;
                }
                else
                {
                    if (i == digits.Length - 1 && digits[i] == 9)
                    {
                        int[] _Result = new int[digits.Length + 1];
                        _Result[0] = 1;
                        for (int n  = 1; n < _Result.Length; n++)
                        {
                            _Result[n] = 0;
                        }
                        return _Result;
                    }
                }
            }
            

            while (true)
            {
                _Sum = digits[digits.Length - _Index] + 1;
                if (_Sum < 10)
                {
                    digits[digits.Length - _Index]++;
                    break;
                }
                else
                {
                    digits[digits.Length - _Index] = 0;
                    _Index++;
                }
            };

            return digits;
        }
    }
}
